package view;
import java.util.Scanner;

import domain.dto.DeptDto;
import domain.dto.RoleDto;
import domain.vo.DeptVo;
import domain.vo.Result;
import domain.vo.RoleVo;
import service.DeptService;
import service.RoleService;
import view.*;
public class MainView {

    public static void printMenu() {
        String menu = """
                ---------------------
                      RBAC 系统
                ---------------------
                |    0...退出系统     |
                |    1...部⻔管理     |
                |    2...⻆⾊管理     |
                |    3...⽤户管理     |
                ---------------------
                请输⼊选项：""";
        System.out.print(menu);
    }

    public static Scanner input;

    static {
        input = new Scanner(System.in);
    }

    /**
     * 显示主界⾯
     * 实现菜单循环显示及功能选择
     */
    public static void show() {
        String menuChoice; // ⽤于存储⽤户输⼊的选项
        do {
            printMenu();
            menuChoice = input.nextLine();
            switch (menuChoice) {
                case "0" -> System.out.println("成功退出系统，欢迎再次使⽤！");
                case "1" -> DeptView.show();
                case "2" -> RoleView.show();
                case "3" -> UserView.show();
                default -> System.out.println("输⼊⾮法，请输⼊正确的菜单编号！");
            }
        } while (!"0".equals(menuChoice));
        input.close();
    }

    public class DeptView {
        /**
         * 显示界⾯
         */
        public static void printError(String message) {
            /* ANSI 转义码，\033[31m表示红⾊，\033[0m表示重置为默认颜⾊ */
            System.out.println("\033[31m" + message + "\033[0m");
        }

        public static DeptVo[] cache;

        public static void printMenu() {
            String menu = """
                    ---------------------
                          部⻔管理
                    ---------------------
                    |    0...返回上级     |
                    |    1...部⻔列表     |
                    |    2...创建部⻔     |
                    |    3...更新部⻔     |
                    |    4...删除部⻔     |
                    ---------------------
                        请输⼊选项：""";
            System.out.print(menu);
        }

        public static void show() {
            String menuChoice;
            do {
                printMenu();
                menuChoice = MainView.input.nextLine();
                switch (menuChoice) {
                    case "0" -> System.out.println("已返回上⼀级菜单");
                    case "1" -> list();
                    case "2" -> create();
                    case "3" -> update();
                    case "4" -> delete();
                    default -> System.out.println("输⼊⾮法，请输⼊正确的菜单编号！");
                }
            } while (!"0".equals(menuChoice));
        }

        public static void list() {
            // 调⽤服务层获取所有部⻔数据
            Result result = DeptService.list();
            // 将获取到的部⻔数据存⼊缓存
            cache = (DeptVo[]) result.data;
            // 输出表头
            System.out.println("ID\t部⻔名称\t部⻔电话");
            // 遍历缓存中的每个部⻔对象，输出部⻔的ID、名称和电话
            for (DeptVo dept : cache) {
                if (dept != null) {
                    // 格式化输出每个部⻔的详细信息
                    System.out.printf("%d\t%s\t%s\n", dept.id, dept.name,
                            dept.phone);
                }
            }
        }

        public static void create() {
            // 提示⽤户输⼊部⻔名称
            System.out.print("请输⼊部⻔名称：");
            String name = MainView.input.nextLine(); // 获取⽤户输⼊的部⻔名称
            // 提示⽤户输⼊部⻔电话
            System.out.print("请输⼊部⻔电话：");
            String phone = MainView.input.nextLine(); // 获取⽤户输⼊的部⻔电话
            // 将⽤户输⼊的部⻔名称和电话封装到DeptDto对象中
            DeptDto dto = new DeptDto(name, phone);
            // 调⽤服务层的创建⽅法，创建新的部⻔
            Result result = DeptService.create(dto);
            // 如果创建操作失败，输出错误信息
            if (!result.success) {
                System.err.println(result.message);
                return; // 结束⽅法执⾏
            }
            // 创建成功，输出成功信息
            System.out.println(result.message);
            // 列出当前所有部⻔信息
            list();
        }

        public static void update() {
            DeptVo dept = getCacheById();
            if (dept == null) {
                return;
            }
            // 提示⽤户输⼊部⻔ID
            System.out.print("请输⼊ID，ID必须是⼤于0的整数：");
            // 验证⽤户输⼊的ID是否为整数
            if (!MainView.input.hasNextInt()) {
                MainView.input.nextLine(); // 清除⽆效输⼊
                System.err.println("ID必须为整数，请输⼊整数值");
                return;
            }
            // 获取⽤户输⼊的ID
            int id = MainView.input.nextInt();
            MainView.input.nextLine(); // 清除输⼊缓存中的换⾏符
            // 验证ID是否⼤于0
            if (id < 1) {
                System.err.println("ID必须⼤于0，请重新输⼊");
                return;
            }
            // 如果缓存为空，则从服务层查询所有部⻔信息并缓存
            if (cache == null) {
                Result result = DeptService.list();
                cache = (DeptVo[]) result.data; // 缓存部⻔数据
            }
            // 在缓存中查找指定ID的部⻔
            for (DeptVo item : cache) {
                if (item.id == id) {
                    // 找到对应ID的部⻔，输出部⻔信息
                    System.out.println("该ID对应的数据是：");
                    System.out.printf("ID：%d，名称：%s，电话：%s\n", item.id,
                            item.name, item.phone);
                    dept = item;
                    break;
                }
            }
            // 如果未找到部⻔，则提示⽤户
            if (dept == null) {
                System.err.println("当前没有该ID对应的数据");
                return;
            }
            // 提示⽤户输⼊新的部⻔名称，按回⻋表示不修改
            System.out.print("请输⼊部⻔名称，直接按回⻋表示不修改：");
            String name = MainView.input.nextLine();
            // 如果⽤户没有输⼊新名称，保持原名称
            name = "".equals(name) ? dept.name : name;
            // 提示⽤户输⼊新的部⻔电话，按回⻋表示不修改
            System.out.print("请输⼊部⻔电话，直接按回⻋表示不修改：");
            String phone = MainView.input.nextLine();
            // 如果⽤户没有输⼊新电话，保持原电话
            phone = "".equals(phone) ? dept.phone : phone;
            // 创建新的 DeptDto 对象，⽤于更新部⻔信息
            DeptDto dto = new DeptDto(name, phone);
            // 调⽤服务层更新部⻔信息
            Result result = DeptService.update(dto, dept.id);
            // 如果更新失败，显示错误信息
            if (!result.success) {
                System.err.println(result.message);
                return;
            }
            // 更新成功，显示成功消息并列出部⻔信息
            System.out.println(result.message);
            list(); // 列出更新后的部⻔列表
        }

        public static void delete() {
            DeptVo dept = getCacheById();
            if (dept == null) {
                return;
            }
            // 提示⽤户输⼊部⻔ID
            System.out.print("请输⼊ID，ID必须是⼤于0的整数：");
            // 验证⽤户输⼊的ID是否为整数
            if (!MainView.input.hasNextInt()) {
                // 清除⽆效输⼊
                MainView.input.nextLine();
                System.err.println("ID必须为整数，请输⼊整数值");
                return;
            }
            // 获取⽤户输⼊的ID
            int id = MainView.input.nextInt();
            // 清除输⼊缓存中的换⾏符
            MainView.input.nextLine();
            // 验证ID是否⼤于0
            if (id < 1) {
                System.err.println("ID必须⼤于0，请重新输⼊");
                return;
            }
            // 如果缓存为空，则从服务层查询所有部⻔信息并缓存
            if (cache == null) {
                // 调⽤服务层获取部⻔列表
                Result result = DeptService.list();
                // 将查询到的部⻔数据缓存
                cache = (DeptVo[]) result.data;
            }
            // 在缓存中查找指定ID的部⻔
            for (DeptVo item : cache) {
                if (item.id == id) {
                    // 找到对应ID的部⻔，输出部⻔信息
                    System.out.println("该ID对应的数据是：");
                    System.out.printf("ID：%d，名称：%s，电话：%s\n", item.id,
                            item.name, item.phone);
                    dept = item;
                    break;
                }
            }
            // 如果未找到部⻔，则提示⽤户
            if (dept == null) {
                System.err.println("当前没有该ID对应的数据");
                return;
            }
            // 提示⽤户确认是否删除
            System.out.print("输⼊'Y'确认删除，输⼊其它取消删除：");
            String confirm = MainView.input.nextLine();
            // 如果⽤户输⼊的不是'Y'或'y'，则取消删除
            if (!"Y".equalsIgnoreCase(confirm)) {
                System.out.println("您已取消删除");
                return;
            }
            // 调⽤服务层进⾏删除操作
            Result result = DeptService.delete(dept.id);
            // 如果删除操作失败，提示错误信息
            if (!result.success) {
                System.err.println(result.message);
                return;
            }
            // 删除成功，输出成功信息并列出当前部⻔列表
            System.out.println(result.message);
            list();
        }

        public static DeptVo getCacheById() {
            // 提示⽤户输⼊部⻔ID
            System.out.print("请输⼊ID，ID必须是⼤于0的整数：");
            // 验证⽤户输⼊的ID是否为整数
            if (!MainView.input.hasNextInt()) {
                // 清除⽆效输⼊
                MainView.input.nextLine();
                System.err.println("ID必须为整数，请输⼊整数值");
                return null;
            }
            // 获取⽤户输⼊的ID
            int id = MainView.input.nextInt();
            // 清除输⼊缓存中的换⾏符
            MainView.input.nextLine();
            // 验证ID是否⼤于0
            if (id < 1) {
                System.out.println("ID必须⼤于0，请重新输⼊");
                return null;
            }
            // 如果缓存为空，则从服务层查询所有部⻔信息并缓存
            if (cache == null) {
                // 调⽤服务层获取部⻔列表
                Result result = DeptService.list();
                // 将查询到的部⻔数据缓存
                cache = (DeptVo[]) result.data;
            }
            // 在缓存中查找指定ID的部⻔
            DeptVo dept = null;
            for (DeptVo item : cache) {
                if (item.id == id) {
                    // 找到对应ID的部⻔，输出部⻔信息
                    System.out.println("该ID对应的数据是：");
                    System.out.printf("ID：%d，名称：%s，电话：%s\n", item.id,
                            item.name, item.phone);
                    dept = item;
                    break;
                }
            }
            // 如果未找到部⻔，则提示⽤户
            if (dept == null) {
                System.err.println("当前没有该ID对应的数据");
                return null;
            }
            return dept;
        }
    }

    public class RoleView {
        public static void printError(String message) {
            /* ANSI 转义码，\033[31m表示红⾊，\033[0m表示重置为默认颜⾊ */
            System.out.println("\033[31m" + message + "\033[0m");
        }

        public static RoleVo[] cache;

        public static void printMenu() {
            String menu = """
                    ---------------------
                            ⻆⾊管理
                    ---------------------
                    |    0...返回上级     |
                    |    1...⻆⾊列表     |
                    |    2...创建⻆⾊     |
                    |    3...更新⻆⾊     |
                    |    4...删除⻆⾊     |
                    ---------------------
                    请输⼊选项：""";
            System.out.print(menu);
        }

        public static void show() {
            String menuChoice;
            do {
                printMenu();
                menuChoice = MainView.input.nextLine();
                switch (menuChoice) {
                    case "0" -> System.out.println("已返回上⼀级菜单");
                    case "1" -> list();
                    case "2" -> create();
                    case "3" -> update();
                    case "4" -> delete();
                    default -> System.out.println("输⼊⾮法，请输⼊正确的菜单编号！");
                }
            } while (!"0".equals(menuChoice));
        }

        public static void list() {
            Result result = RoleService.list();

            cache = (RoleVo[]) result.data;
            // 输出表头
            System.out.println("ID\t⻆⾊名称\t数据访问范围");

            for (RoleVo role : cache) {
                if (role != null) {

                    System.out.printf("%d\t%s\t%s\n", role.id, role.name,
                            role.dataScope);
                }
            }
        }

        public static void create() {
            System.out.print("请输⼊角色名称：");
            String name = MainView.input.nextLine();
            System.out.print("请输⼊数据访问范围：");
            String dataScope = MainView.input.nextLine();

            RoleDto dto = new RoleDto(name, dataScope);

            Result result = RoleService.create(dto);

            if (!result.success) {
                System.err.println(result.message);
                return; // 结束⽅法执⾏
            }
            // 创建成功，输出成功信息
            System.out.println(result.message);

            list();
        }

        public static void update() {
            RoleVo role = getCacheById();
            if (role == null) {
                return;
            }
            // 提示⽤户输⼊部⻔ID
            System.out.print("请输⼊ID，ID必须是⼤于0的整数：");
            // 验证⽤户输⼊的ID是否为整数
            if (!MainView.input.hasNextInt()) {
                MainView.input.nextLine(); // 清除⽆效输⼊
                System.err.println("ID必须为整数，请输⼊整数值");
                return;
            }
            // 获取⽤户输⼊的ID
            int id = MainView.input.nextInt();
            MainView.input.nextLine(); // 清除输⼊缓存中的换⾏符
            // 验证ID是否⼤于0
            if (id < 1) {
                System.err.println("ID必须⼤于0，请重新输⼊");
                return;
            }

            if (cache == null) {
                Result result = RoleService.list();
                cache = (RoleVo[]) result.data;
            }

            for (RoleVo item : cache) {
                if (item.id == id) {
                    System.out.println("该ID对应的数据是：");
                    System.out.printf("ID：%d，名称：%s，数据访问范围：%s\n", item.id,
                            item.name, item.dataScope);
                    role = item;
                    break;
                }
            }

            if (role == null) {
                System.err.println("当前没有该ID对应的数据");
                return;
            }

            System.out.print("请输⼊角色名称，直接按回⻋表示不修改：");
            String name = MainView.input.nextLine();
            // 如果⽤户没有输⼊新名称，保持原名称
            name = "".equals(name) ? role.name : name;

            System.out.print("请输⼊⻆⾊数据访问范围，输⼊的值应该为 [个⼈、部⻔、全局] 其中之⼀，直接按回⻋表示不修改：");
            // 定义变量 dataScope，⽤于存储⽤户输⼊的合法数据访问范围
            String dataScope = null;
            // 使⽤ do - while 循环，持续获取⽤户输⼊，直⾄得到⼀个合法的值
            do {
                // 从控制台读取⽤户输⼊的字符串
                String str = MainView.input.nextLine();
                // 若⽤户直接按下回⻋键，未输⼊任何内容，则保持原⻆⾊的数据访问范围不变
                if ("".equals(str)) {
                    dataScope = role.dataScope;
                }
                // 若⽤户输⼊的值为 "个⼈"、"部⻔" 或 "全局"，则将其作为合法值存储到dataScope 中
                else if ("个⼈".equals(str) || "部⻔".equals(str) || "全局".equals(str)) {
                    dataScope = str;
                }
                // 若⽤户输⼊的值不在合法范围内，给出错误提示，并要求⽤户重新输⼊
                else {
                    System.err.print("输⼊的值不合法，输⼊的值应该为 [个⼈、部⻔、全局] 其中之⼀，直接按回⻋表示不修改，请重新输⼊：");
                }
                // 只要 dataScope 仍为 null，说明⽤户尚未输⼊合法值，继续循环获取输⼊
            } while (dataScope == null);

            RoleDto dto = new RoleDto(name, dataScope);

            Result result = RoleService.update(dto, role.id);
            // 如果更新失败，显示错误信息
            if (!result.success) {
                System.err.println(result.message);
                return;
            }

            System.out.println(result.message);
            list();
        }

        public static void delete() {
            RoleVo role = getCacheById();
            if (role == null) {
                return;
            }
            // 提示⽤户输⼊部⻔ID
            System.out.print("请输⼊ID，ID必须是⼤于0的整数：");
            // 验证⽤户输⼊的ID是否为整数
            if (!MainView.input.hasNextInt()) {
                // 清除⽆效输⼊
                MainView.input.nextLine();
                System.err.println("ID必须为整数，请输⼊整数值");
                return;
            }
            // 获取⽤户输⼊的ID
            int id = MainView.input.nextInt();
            // 清除输⼊缓存中的换⾏符
            MainView.input.nextLine();
            // 验证ID是否⼤于0
            if (id < 1) {
                System.err.println("ID必须⼤于0，请重新输⼊");
                return;
            }

            if (cache == null) {

                Result result = RoleService.list();

                cache = (RoleVo[]) result.data;
            }

            for (RoleVo item : cache) {
                if (item.id == id) {

                    System.out.println("该ID对应的数据是：");
                    System.out.printf("ID：%d，名称：%s，数据访问范围：%s\n", item.id,
                            item.name, item.dataScope);
                    role = item;
                    break;
                }
            }

            if (role == null) {
                System.err.println("当前没有该ID对应的数据");
                return;
            }
            // 提示⽤户确认是否删除
            System.out.print("输⼊'Y'确认删除，输⼊其它取消删除：");
            String confirm = MainView.input.nextLine();
            // 如果⽤户输⼊的不是'Y'或'y'，则取消删除
            if (!"Y".equalsIgnoreCase(confirm)) {
                System.out.println("您已取消删除");
                return;
            }
            // 调⽤服务层进⾏删除操作
            Result result = RoleService.delete(role.id);
            // 如果删除操作失败，提示错误信息
            if (!result.success) {
                System.err.println(result.message);
                return;
            }

            System.out.println(result.message);
            list();
        }

        public static RoleVo getCacheById() {

            System.out.print("请输⼊ID，ID必须是⼤于0的整数：");
            // 验证⽤户输⼊的ID是否为整数
            if (!MainView.input.hasNextInt()) {
                // 清除⽆效输⼊
                MainView.input.nextLine();
                System.err.println("ID必须为整数，请输⼊整数值");
                return null;
            }
            // 获取⽤户输⼊的ID
            int id = MainView.input.nextInt();
            // 清除输⼊缓存中的换⾏符
            MainView.input.nextLine();
            // 验证ID是否⼤于0
            if (id < 1) {
                System.out.println("ID必须⼤于0，请重新输⼊");
                return null;
            }

            if (cache == null) {

                Result result = RoleService.list();

                cache = (RoleVo[]) result.data;
            }

            RoleVo role = null;
            for (RoleVo item : cache) {
                if (item.id == id) {

                    System.out.println("该ID对应的数据是：");
                    System.out.printf("ID：%d，名称：%s，数据访问范围：%s\n", item.id,
                            item.name, item.dataScope);
                    role = item;
                    break;
                }
            }
            // 如果未找到部⻔，则提示⽤户
            if (role == null) {
                System.err.println("当前没有该ID对应的数据");
                return null;
            }
            return role;
        }


    }
}








